home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termASCIITransfer.c < prev    next >
C/C++ Source or Header  |  1995-02-07  |  24KB  |  1,318 lines
  1. /*
  2. **    termASCIITransfer.c
  3. **
  4. **    ASCII file transfer routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termARexxGlobal.h"
  11.  
  12.     /* Local variables. */
  13.  
  14. STATIC LONG        WaitCount,PromptCount;
  15. STATIC UBYTE __far    ASCIISendPrompt[256];
  16. STATIC LONG        ASCIISendPromptLen;
  17. STATIC BYTE        (* ASCIISendLine)(register STRPTR,register LONG);
  18.  
  19. STATIC LONG __regargs
  20. MangleASCIIBuffer(BYTE TranslateCR,BYTE TranslateLF,STRPTR Source,LONG SourceLen,STRPTR Destination)
  21. {
  22.     WORD    CR_Len,
  23.         LF_Len;
  24.     STRPTR    CR_String,
  25.         LF_String;
  26.     UBYTE    Mask;
  27.     LONG    Len = 0;
  28.  
  29.     switch(TranslateCR)
  30.     {
  31.         case EOL_IGNORE:
  32.  
  33.             CR_Len = 0;
  34.             break;
  35.  
  36.         case EOL_CR:
  37.  
  38.             CR_Len        = 1;
  39.             CR_String    = "\r";
  40.             break;
  41.  
  42.         case EOL_LF:
  43.  
  44.             CR_Len        = 1;
  45.             CR_String    = "\n";
  46.             break;
  47.  
  48.         case EOL_CRLF:
  49.  
  50.             CR_Len        = 2;
  51.             CR_String    = "\r\n";
  52.             break;
  53.  
  54.         case EOL_LFCR:
  55.  
  56.             CR_Len        = 2;
  57.             CR_String    = "\n\r";
  58.             break;
  59.     }
  60.  
  61.     switch(TranslateLF)
  62.     {
  63.         case EOL_IGNORE:
  64.  
  65.             LF_Len = 0;
  66.             break;
  67.  
  68.         case EOL_LF:
  69.  
  70.             LF_Len        = 1;
  71.             LF_String    = "\n";
  72.             break;
  73.  
  74.         case EOL_CR:
  75.  
  76.             LF_Len        = 1;
  77.             LF_String    = "\r";
  78.             break;
  79.  
  80.         case EOL_LFCR:
  81.  
  82.             LF_Len        = 2;
  83.             LF_String    = "\n\r";
  84.             break;
  85.  
  86.         case EOL_CRLF:
  87.  
  88.             LF_Len        = 2;
  89.             LF_String    = "\r\n";
  90.             break;
  91.     }
  92.  
  93.     if(Config -> TransferConfig -> StripBit8)
  94.         Mask = 0x7F;
  95.     else
  96.         Mask = 0xFF;
  97.  
  98.     do
  99.     {
  100.         switch(*Source)
  101.         {
  102.             case '\r':
  103.  
  104.                 if(CR_Len)
  105.                 {
  106.                     CopyMem(CR_String,Destination,CR_Len);
  107.  
  108.                     Destination    += CR_Len;
  109.                     Len        += CR_Len;
  110.                 }
  111.  
  112.                 break;
  113.  
  114.             case '\n':
  115.  
  116.                 if(LF_Len)
  117.                 {
  118.                     CopyMem(LF_String,Destination,LF_Len);
  119.  
  120.                     Destination    += LF_Len;
  121.                     Len        += LF_Len;
  122.                 }
  123.  
  124.                 break;
  125.  
  126.             default:
  127.  
  128.                 *Destination++ = (*Source) & Mask;
  129.  
  130.                 Len++;
  131.  
  132.                 break;
  133.         }
  134.  
  135.         Source++;
  136.     }
  137.     while(--SourceLen);
  138.  
  139.     return(Len);
  140. }
  141.  
  142.     /* MatchPrompt():
  143.      *
  144.      *    Search incoming data stream for a match.
  145.      */
  146.  
  147. STATIC BYTE __regargs
  148. MatchPrompt(register STRPTR Data,register LONG Size,register STRPTR Prompt,register LONG PromptLen)
  149. {
  150.     register UBYTE c,Mask;
  151.  
  152.     if(Config -> SerialConfig -> StripBit8)
  153.         Mask = 0x7F;
  154.     else
  155.         Mask = 0xFF;
  156.  
  157.     do
  158.     {
  159.         if(c = ((*Data++) & Mask))
  160.         {
  161.             register BYTE MatchMade;
  162.  
  163.             do
  164.             {
  165.                 MatchMade = FALSE;
  166.  
  167.                 if(PromptCount == WaitCount)
  168.                 {
  169.                     if(c == Prompt[WaitCount] & Mask)
  170.                     {
  171.                         MatchMade = TRUE;
  172.  
  173.                         if(PromptLen == ++PromptCount)
  174.                             return(TRUE);
  175.                     }
  176.                 }
  177.  
  178.                 if(MatchMade)
  179.                     WaitCount++;
  180.                 else
  181.                 {
  182.                     if(WaitCount)
  183.                     {
  184.                         WaitCount = 0;
  185.  
  186.                         PromptCount = 0;
  187.                     }
  188.                     else
  189.                         break;
  190.                 }
  191.             }
  192.             while(!WaitCount);
  193.         }
  194.     }
  195.     while(--Size);
  196.  
  197.     return(FALSE);
  198. }
  199.  
  200.     /* WaitForPrompt(STRPTR Prompt,LONG PromptLen):
  201.      *
  202.      *    Scan the incoming data flow for a certain string.
  203.      */
  204.  
  205. STATIC BYTE __regargs
  206. WaitForPrompt(STRPTR Prompt,LONG PromptLen)
  207. {
  208.     ULONG Signals;
  209.  
  210.     WaitCount = PromptCount = 0;
  211.  
  212.     if(DataHold)
  213.     {
  214.         DataHold = NULL;
  215.  
  216.         RestartSerial(FALSE);
  217.     }
  218.  
  219.     if(CheckSerialRead())
  220.         Signals = SIG_SERIAL;
  221.     else
  222.         Signals = NULL;
  223.  
  224.     StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  225.  
  226.     for(;;)
  227.     {
  228.         if(Signals & SIG_SERIAL)
  229.         {
  230.             if(!WaitSerialRead())
  231.             {
  232.                 LONG Length;
  233.  
  234.                 BytesIn++;
  235.  
  236.                 ConProcess(ReadBuffer,1);
  237.  
  238.                 Status = STATUS_READY;
  239.  
  240.                 if(MatchPrompt(ReadBuffer,1,Prompt,PromptLen))
  241.                 {
  242.                     if(!CheckIO(TimeRequest))
  243.                         AbortIO(TimeRequest);
  244.  
  245.                     WaitIO(TimeRequest);
  246.  
  247.                     RestartSerial(FALSE);
  248.  
  249.                     return(TRUE);
  250.                 }
  251.  
  252.                 do
  253.                 {
  254.                         /* Check how many bytes are still in
  255.                          * the serial buffer.
  256.                          */
  257.  
  258.                     if(Length = GetSerialWaiting())
  259.                     {
  260.                         if(Length > SerialBufferSize)
  261.                             Length = SerialBufferSize;
  262.  
  263.                         if(!DoSerialRead(ReadBuffer,Length))
  264.                         {
  265.                             BytesIn += Length;
  266.  
  267.                             ConProcess(ReadBuffer,Length);
  268.  
  269.                             Status = STATUS_READY;
  270.  
  271.                             if(MatchPrompt(ReadBuffer,Length,Prompt,PromptLen))
  272.                             {
  273.                                 if(!CheckIO(TimeRequest))
  274.                                     AbortIO(TimeRequest);
  275.  
  276.                                 WaitIO(TimeRequest);
  277.  
  278.                                 RestartSerial(FALSE);
  279.  
  280.                                 return(TRUE);
  281.                             }
  282.                         }
  283.                     }
  284.                 }
  285.                 while(Length);
  286.             }
  287.  
  288.             RestartSerial(FALSE);
  289.         }
  290.  
  291.         if(Signals & SIG_TIMER)
  292.         {
  293.             WaitIO(TimeRequest);
  294.  
  295.             return(FALSE);
  296.         }
  297.  
  298.         Signals = Wait(SIG_SERIAL | SIG_TIMER);
  299.     }
  300. }
  301.  
  302.     /* ASCIISendLinePrompt(STRPTR Line,LONG Len):
  303.      *
  304.      *    Send text line, wait for prompt.
  305.      */
  306.  
  307. STATIC BYTE
  308. ASCIISendLinePrompt(STRPTR Line,LONG Len)
  309. {
  310.     LONG i;
  311.  
  312.     if(Len == -1)
  313.         Len = strlen(Line);
  314.  
  315.     while(Len)
  316.     {
  317.         i = 0;
  318.  
  319.         while(i < Len && Line[i] != '\r')
  320.             i++;
  321.  
  322.  
  323.         if(Line[i] == '\r')
  324.         {
  325.             i++;
  326.  
  327.             SerWrite(Line,i);
  328.  
  329.             if(!WaitForPrompt(ASCIISendPrompt,ASCIISendPromptLen))
  330.                 return(FALSE);
  331.         }
  332.         else
  333.         {
  334.             if(i)
  335.                 SerWrite(Line,i);
  336.         }
  337.  
  338.         Len    -= i;
  339.         Line    += i;
  340.     }
  341.  
  342.     return(TRUE);
  343. }
  344.  
  345.     /* ASCIISendLineSimple(STRPTR Line,LONG Len):
  346.      *
  347.      *    Send a text line, no fancy features.
  348.      */
  349.  
  350. STATIC BYTE
  351. ASCIISendLineSimple(STRPTR Line,LONG Len)
  352. {
  353.     if(Len == -1)
  354.         Len = strlen(Line);
  355.  
  356.     SerWrite(Line,Len);
  357.  
  358.     return(TRUE);
  359. }
  360.  
  361.     /* ASCIISendLineDelay(STRPTR Line,LONG Len):
  362.      *
  363.      *    Send a text line, include a delay where necessary.
  364.      */
  365.  
  366. STATIC BYTE
  367. ASCIISendLineDelay(STRPTR Line,LONG Len)
  368. {
  369.     if(Len == -1)
  370.         Len = strlen(Line);
  371.  
  372.     while(Len--)
  373.     {
  374.         SerWrite(Line,1);
  375.  
  376.         if(*Line == '\r')
  377.         {
  378.             if(Config -> TransferConfig -> LineDelay)
  379.                 WaitTime(Config -> TransferConfig -> LineDelay / 100,(Config -> TransferConfig -> LineDelay % 100) * 10000);
  380.         }
  381.         else
  382.         {
  383.             if(Config -> TransferConfig -> CharDelay)
  384.                 WaitTime(Config -> TransferConfig -> CharDelay / 100,(Config -> TransferConfig -> CharDelay % 100) * 10000);
  385.         }
  386.  
  387.         Line++;
  388.     }
  389.  
  390.     return(TRUE);
  391. }
  392.  
  393.     /* ASCIISendLineEcho(STRPTR Line,LONG Len):
  394.      *
  395.      *    Send a text line, wait for single characters to be echoed.
  396.      */
  397.  
  398. STATIC BYTE
  399. ASCIISendLineEcho(STRPTR Line,LONG Len)
  400. {
  401.     ULONG Signals;
  402.  
  403.     if(DataHold)
  404.     {
  405.         DataHold = NULL;
  406.  
  407.         RestartSerial(FALSE);
  408.     }
  409.  
  410.     if(Len == -1)
  411.         Len = strlen(Line);
  412.  
  413.     while(Len--)
  414.     {
  415.         SerWrite(Line,1);
  416.  
  417.         StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  418.  
  419.         FOREVER
  420.         {
  421.             Signals = Wait(SIG_TIMER | SIG_SERIAL);
  422.  
  423.             if(Signals & SIG_SERIAL)
  424.             {
  425.                 if(!WaitSerialRead())
  426.                 {
  427.                     if(*(UBYTE *)ReadBuffer == *Line)
  428.                     {
  429.                         if(!CheckIO(TimeRequest))
  430.                             AbortIO(TimeRequest);
  431.  
  432.                         WaitIO(TimeRequest);
  433.  
  434.                         RestartSerial(FALSE);
  435.  
  436.                         break;
  437.                     }
  438.  
  439.                     RestartSerial(FALSE);
  440.                 }
  441.                 else
  442.                 {
  443.                     if(!CheckIO(TimeRequest))
  444.                         AbortIO(TimeRequest);
  445.  
  446.                     WaitIO(TimeRequest);
  447.  
  448.                     RestartSerial(FALSE);
  449.  
  450.                     return(FALSE);
  451.                 }
  452.             }
  453.  
  454.             if(Signals & SIG_TIMER)
  455.             {
  456.                 WaitIO(TimeRequest);
  457.  
  458.                 return(FALSE);
  459.             }
  460.         }
  461.  
  462.         Line++;
  463.     }
  464.  
  465.     return(TRUE);
  466. }
  467.  
  468.     /* ASCIISendLineAnyEcho(STRPTR Line,LONG Len):
  469.      *
  470.      *    Send a text line, wait for characters to be echoed.
  471.      */
  472.  
  473. STATIC BYTE
  474. ASCIISendLineAnyEcho(STRPTR Line,LONG Len)
  475. {
  476.     ULONG Signals;
  477.  
  478.     if(DataHold)
  479.     {
  480.         DataHold = NULL;
  481.  
  482.         RestartSerial(FALSE);
  483.     }
  484.  
  485.     if(Len == -1)
  486.         Len = strlen(Line);
  487.  
  488.     while(Len--)
  489.     {
  490.         SerWrite(Line,1);
  491.  
  492.         StartTime(Config -> TransferConfig -> SendTimeout / 100,(Config -> TransferConfig -> SendTimeout % 100) * 10000);
  493.  
  494.         FOREVER
  495.         {
  496.             Signals = Wait(SIG_TIMER | SIG_SERIAL);
  497.  
  498.             if(Signals & SIG_SERIAL)
  499.             {
  500.                 if(!WaitSerialRead())
  501.                 {
  502.                     if(!CheckIO(TimeRequest))
  503.                         AbortIO(TimeRequest);
  504.  
  505.                     WaitIO(TimeRequest);
  506.  
  507.                     RestartSerial(FALSE);
  508.  
  509.                     break;
  510.                 }
  511.                 else
  512.                 {
  513.                     if(!CheckIO(TimeRequest))
  514.                         AbortIO(TimeRequest);
  515.  
  516.                     WaitIO(TimeRequest);
  517.  
  518.                     RestartSerial(FALSE);
  519.  
  520.                     return(FALSE);
  521.                 }
  522.             }
  523.  
  524.             if(Signals & SIG_TIMER)
  525.             {
  526.                 WaitIO(TimeRequest);
  527.  
  528.                 return(FALSE);
  529.             }
  530.         }
  531.  
  532.         Line++;
  533.     }
  534.  
  535.     return(TRUE);
  536. }
  537.  
  538.     /* ASCIISendLineKeyDelay(STRPTR Line,LONG Len):
  539.      *
  540.      *    Send a text line, include keyboard delay pauses between characters.
  541.      */
  542.  
  543. STATIC BYTE
  544. ASCIISendLineKeyDelay(STRPTR Line,LONG Len)
  545. {
  546.     struct Preferences Prefs;
  547.  
  548.     if(Len == -1)
  549.         Len = strlen(Line);
  550.  
  551.         /* Get current key repeat delay. */
  552.  
  553.     GetPrefs(&Prefs,offsetof(struct Preferences,KeyRptDelay));
  554.  
  555.         /* Any delay specified at all? */
  556.  
  557.     if(Prefs . KeyRptSpeed . tv_secs || Prefs . KeyRptSpeed . tv_micro)
  558.     {
  559.         while(Len--)
  560.         {
  561.             SerWrite(Line++,1);
  562.  
  563.             if(Len)
  564.             {
  565.                 TimeRequest -> tr_node . io_Command    = TR_ADDREQUEST;
  566.                 TimeRequest -> tr_time            = Prefs . KeyRptSpeed;
  567.  
  568.                 DoIO(TimeRequest);
  569.             }
  570.         }
  571.     }
  572.     else
  573.         SerWrite(Line,Len);
  574.  
  575.     return(TRUE);
  576. }
  577.  
  578.     /* ASCIOSendSetup():
  579.      *
  580.      *    Choose the right routine for the text line output job.
  581.      */
  582.  
  583. VOID
  584. ASCIISendSetup()
  585. {
  586.         /* Pick the line send routine. */
  587.  
  588.     switch(Config -> TransferConfig -> PacingMode)
  589.     {
  590.         case PACE_DIRECT:
  591.  
  592.             ASCIISendLine = ASCIISendLineSimple;
  593.             break;
  594.  
  595.         case PACE_ECHO:
  596.  
  597.             if(Config -> TransferConfig -> SendTimeout)
  598.                 ASCIISendLine = ASCIISendLineEcho;
  599.             else
  600.                 ASCIISendLine = ASCIISendLineSimple;
  601.  
  602.             break;
  603.  
  604.         case PACE_ANYECHO:
  605.  
  606.             if(Config -> TransferConfig -> SendTimeout)
  607.                 ASCIISendLine = ASCIISendLineAnyEcho;
  608.             else
  609.                 ASCIISendLine = ASCIISendLineSimple;
  610.  
  611.             break;
  612.  
  613.         case PACE_PROMPT:
  614.  
  615.             if(Config -> TransferConfig -> SendTimeout)
  616.             {
  617.                     /* Prepare the prompt string. */
  618.  
  619.                 if(Config -> TransferConfig -> LinePrompt[0])
  620.                     ASCIISendPromptLen = TranslateString(Config -> TransferConfig -> LinePrompt,ASCIISendPrompt);
  621.                 else
  622.                 {
  623.                     ASCIISendPrompt[0] = 0;
  624.                     ASCIISendPromptLen = 0;
  625.                 }
  626.  
  627.                 ASCIISendLine = ASCIISendLinePrompt;
  628.             }
  629.             else
  630.                 ASCIISendLine = ASCIISendLineSimple;
  631.  
  632.             break;
  633.  
  634.         case PACE_DELAY:
  635.  
  636.             if(Config -> TransferConfig -> LineDelay || Config -> TransferConfig -> CharDelay)
  637.                 ASCIISendLine = ASCIISendLineDelay;
  638.             else
  639.                 ASCIISendLine = ASCIISendLineSimple;
  640.  
  641.             break;
  642.  
  643.         case PACE_KEYBOARD:
  644.  
  645.             ASCIISendLine = ASCIISendLineKeyDelay;
  646.             break;
  647.     }
  648. }
  649.  
  650. BYTE __regargs
  651. InternalASCIIUpload(STRPTR SingleFile,BYTE WaitForIt)
  652. {
  653.     BYTE    OldStatus = Status,DidSend = FALSE;
  654.     BPTR    NewDir,OldDir;
  655.  
  656.         /* We are uploading data. */
  657.  
  658.     Uploading = TRUE;
  659.  
  660.     if(NewDir = Lock(Config -> PathConfig -> ASCIIUploadPath,ACCESS_READ))
  661.         OldDir = CurrentDir(NewDir);
  662.     else
  663.         OldDir = NULL;
  664.  
  665.     BlockWindows();
  666.  
  667.     if(!FileTransferInfo)
  668.     {
  669.         if(SingleFile)
  670.         {
  671.             ULONG Size;
  672.  
  673.             if(Size = GetFileSize(SingleFile))
  674.             {
  675.                 if(FileTransferInfo = AllocFileTransferInfo())
  676.                 {
  677.                     if(!AddFileTransferNode(FileTransferInfo,SingleFile,Size))
  678.                     {
  679.                         FreeFileTransferInfo(FileTransferInfo);
  680.  
  681.                         FileTransferInfo = NULL;
  682.                     }
  683.                 }
  684.             }
  685.         }
  686.         else
  687.         {
  688.             struct FileRequester    *FileRequest;
  689.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  690.  
  691.             if(FileRequest = GetFile(Window,LocaleString(MSG_TERMTRANSFER_UPLOAD_FILE_TXT + TRANSFER_ASCII),Config -> PathConfig -> ASCIIUploadPath,"",DummyBuffer,"",FALSE,TRUE,FALSE,LocaleString(MSG_TERMTRANSFER_SEND_TXT),TRUE))
  692.             {
  693.                 strcpy(Config -> PathConfig -> ASCIIUploadPath,FileRequest -> rf_Dir);
  694.  
  695.                 ConfigChanged = TRUE;
  696.  
  697.                 FileTransferInfo = BuildFileTransferInfo(FileRequest);
  698.  
  699.                 FreeAslRequest(FileRequest);
  700.             }
  701.         }
  702.     }
  703.     else
  704.     {
  705.         if(SingleFile)
  706.         {
  707.             ULONG Size;
  708.  
  709.             if(Size = GetFileSize(SingleFile))
  710.             {
  711.                 if(!AddFileTransferNode(FileTransferInfo,SingleFile,Size))
  712.                 {
  713.                     FreeFileTransferInfo(FileTransferInfo);
  714.  
  715.                     FileTransferInfo = NULL;
  716.                 }
  717.             }
  718.         }
  719.     }
  720.  
  721.     TransferAborted = FALSE;
  722.  
  723.     TransferFailed = TRUE;
  724.  
  725.     TransferError = FALSE;
  726.  
  727.     if(FileTransferInfo)
  728.     {
  729.         struct Window *ThisWindow;
  730.  
  731.         if(ThisWindow = CreateASCIIWindow(TRUE))
  732.         {
  733.             struct Buffer    *File;
  734.             LONG         Chars = 0,Lines = 0,Len,i;
  735.             BYTE         Terminated = FALSE;
  736.  
  737.             FileTransferInfo -> DoneSize    = 0;
  738.             FileTransferInfo -> DoneFiles    = 0;
  739.  
  740.             FileTransferInfo -> CurrentFile    = (struct FileTransferNode *)FileTransferInfo -> FileList . mlh_Head;
  741.             FileTransferInfo -> CurrentSize    = FileTransferInfo -> CurrentFile -> Size;
  742.  
  743.             Status = STATUS_UPLOAD;
  744.  
  745.             ASCIISendSetup();
  746.  
  747.             if(DataHold)
  748.             {
  749.                 if(!Config -> TransferConfig -> QuietTransfer)
  750.                 {
  751.                     ConProcess(DataHold,DataSize);
  752.  
  753.                     Status = STATUS_UPLOAD;
  754.                 }
  755.  
  756.                 DataHold = NULL;
  757.  
  758.                 RestartSerial(FALSE);
  759.             }
  760.  
  761.             while(!Terminated && FileTransferInfo -> CurrentFile -> Node . mln_Succ)
  762.             {
  763.                 if(File = BufferOpen(FileTransferInfo -> CurrentFile -> Name,"r"))
  764.                 {
  765.                     UBYTE    DummyBuffer[512],
  766.                         OtherBuffer[256];
  767.                     ULONG    Signals;
  768.                     BYTE    LastCR = FALSE,Skipped = FALSE;
  769.  
  770.                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_OPENING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  771.  
  772.                     while(!Skipped && !Terminated && (Len = BufferRead(File,OtherBuffer,256)) > 0)
  773.                     {
  774.                         if(Len = MangleASCIIBuffer(Config -> TransferConfig -> SendCR,Config -> TransferConfig -> SendLF,OtherBuffer,Len,DummyBuffer))
  775.                         {
  776.                             for(i = 0 ; i < Len ; i++)
  777.                             {
  778.                                 if(DummyBuffer[i] == '\r')
  779.                                 {
  780.                                     Lines++;
  781.  
  782.                                     LastCR = TRUE;
  783.                                 }
  784.                                 else
  785.                                 {
  786.                                     if(DummyBuffer[i] == '\n' && !LastCR)
  787.                                         Lines++;
  788.  
  789.                                     LastCR = FALSE;
  790.                                 }
  791.                             }
  792.  
  793.                             Chars += Len;
  794.  
  795.                             DidSend = TRUE;
  796.  
  797.                             TransferFailed = FALSE;
  798.  
  799.                             (*ASCIISendLine)(DummyBuffer,Len);
  800.                         }
  801.  
  802.                         Signals = CheckSignal(SIG_BREAK | SIG_SERIAL | PORTMASK(ThisWindow -> UserPort));
  803.  
  804.                         if(Signals & SIG_BREAK)
  805.                             Terminated = TransferAborted = TRUE;
  806.  
  807.                         if(Signals & PORTMASK(ThisWindow -> UserPort))
  808.                         {
  809.                             switch(HandleASCIIWindow(ThisWindow))
  810.                             {
  811.                                 case 1:    Terminated = TransferAborted = TRUE;
  812.                                     break;
  813.  
  814.                                 case 2:    Skipped = TRUE;
  815.                                     break;
  816.                             }
  817.  
  818.                             if(Terminated || Skipped)
  819.                                 break;
  820.                         }
  821.  
  822.                         if(Signals & SIG_SERIAL)
  823.                         {
  824.                             if(!WaitSerialRead())
  825.                             {
  826.                                 LONG Length;
  827.  
  828.                                 if(!Config -> TransferConfig -> QuietTransfer)
  829.                                 {
  830.                                     BytesIn++;
  831.  
  832.                                     ConProcess(ReadBuffer,1);
  833.  
  834.                                     Status = STATUS_UPLOAD;
  835.                                 }
  836.  
  837.                                     /* Check how many bytes are still in
  838.                                      * the serial buffer.
  839.                                      */
  840.  
  841.                                 if(Length = GetSerialWaiting())
  842.                                 {
  843.                                     if(Length > SerialBufferSize)
  844.                                         Length = SerialBufferSize;
  845.  
  846.                                     if(Length > Config -> SerialConfig -> Quantum)
  847.                                         Length = Config -> SerialConfig -> Quantum;
  848.  
  849.                                     if(!DoSerialRead(ReadBuffer,Length))
  850.                                     {
  851.                                         if(!Config -> TransferConfig -> QuietTransfer)
  852.                                         {
  853.                                             BytesIn += Length;
  854.  
  855.                                                 /* Send the data to the console. */
  856.  
  857.                                             ConProcess(ReadBuffer,Length);
  858.  
  859.                                             Status = STATUS_UPLOAD;
  860.                                         }
  861.                                     }
  862.                                 }
  863.                             }
  864.  
  865.                             RestartSerial(FALSE);
  866.                         }
  867.  
  868.                         UpdateASCIIWindow(ThisWindow,Chars,FileTransferInfo -> CurrentFile -> Size,Lines);
  869.                     }
  870.  
  871.                     if(Len < 0)
  872.                     {
  873.                         AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_READING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  874.  
  875.                         TransferFailed = TRUE;
  876.  
  877.                         break;
  878.                     }
  879.  
  880.                     BufferClose(File);
  881.  
  882.                     RemoveUploadListItem(FileTransferInfo -> CurrentFile -> Name);
  883.                 }
  884.                 else
  885.                 {
  886.                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_OPENING_FILE_TXT),FileTransferInfo -> CurrentFile -> Name);
  887.  
  888.                     TransferFailed = TRUE;
  889.  
  890.                     break;
  891.                 }
  892.  
  893.                 FileTransferInfo -> DoneSize    += FileTransferInfo -> CurrentSize;
  894.                 FileTransferInfo -> DoneFiles    += 1;
  895.  
  896.                 FileTransferInfo -> CurrentFile  = (struct FileTransferNode *)FileTransferInfo -> CurrentFile -> Node . mln_Succ;
  897.                 FileTransferInfo -> CurrentSize  = FileTransferInfo -> CurrentFile -> Size;
  898.             }
  899.  
  900.             if(TransferFailed || TransferError)
  901.                 WakeUp(ThisWindow,SOUND_BADTRANSFER);
  902.             else
  903.             {
  904.                 WakeUp(ThisWindow,SOUND_GOODTRANSFER);
  905.  
  906.                 WaitTime(2,0);
  907.             }
  908.  
  909.             DeleteASCIIWindow(ThisWindow,TransferFailed && WaitForIt);
  910.         }
  911.  
  912.         FreeFileTransferInfo(FileTransferInfo);
  913.  
  914.         FileTransferInfo = NULL;
  915.     }
  916.  
  917.     if(TransferFailed || TransferAborted)
  918.         Say(LocaleString(MSG_GLOBAL_TRANSFER_FAILED_OR_ABORTED_TXT));
  919.     else
  920.         Say(LocaleString(MSG_GLOBAL_TRANSFER_COMPLETED_TXT));
  921.  
  922.     if(OldDir)
  923.         CurrentDir(OldDir);
  924.  
  925.     if(NewDir)
  926.         UnLock(NewDir);
  927.  
  928.     SendAbort = FALSE;
  929.  
  930.     Status = OldStatus;
  931.  
  932.     ReleaseWindows();
  933.  
  934.     DidTransfer = FALSE;
  935.  
  936.     if(WaitForIt)
  937.     {
  938.         if(Config -> CommandConfig -> DownloadMacro[0])
  939.             SerialCommand(Config -> CommandConfig -> DownloadMacro);
  940.     }
  941.  
  942.     DidTransfer = FALSE;
  943.  
  944.     return(DidSend);
  945. }
  946.  
  947. BYTE __regargs
  948. InternalASCIIDownload(STRPTR Name,BYTE WaitForIt)
  949. {
  950.     struct FileRequester    *FileRequest;
  951.     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  952.     BYTE             OldStatus = Status,DidSend = FALSE;
  953.     BPTR             NewDir,OldDir;
  954.  
  955.     ClearGenericList(GenericListTable[GLIST_DOWNLOAD]);
  956.  
  957.     DownloadPath = Config -> PathConfig -> ASCIIDownloadPath;
  958.  
  959.     if(DownloadPath[0])
  960.     {
  961.         if(NewDir = Lock(DownloadPath,ACCESS_READ))
  962.             OldDir = CurrentDir(NewDir);
  963.         else
  964.             OldDir = NULL;
  965.     }
  966.     else
  967.         NewDir = OldDir = NULL;
  968.  
  969.     BlockWindows();
  970.  
  971.     if(!Name)
  972.     {
  973.         if(FileRequest = GetFile(Window,LocaleString(MSG_TERMTRANSFER_DOWNLOAD_FILE_TXT + TRANSFER_ASCII),DownloadPath,"",DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_TERMTRANSFER_RECEIVE_TXT),TRUE))
  974.         {
  975.                 /* Save the download path. */
  976.  
  977.             strcpy(DownloadPath,FileRequest -> rf_Dir);
  978.  
  979.             ConfigChanged = TRUE;
  980.  
  981.             FreeAslRequest(FileRequest);
  982.  
  983.             Name = DummyBuffer;
  984.         }
  985.     }
  986.     else
  987.     {
  988.         STRPTR Index;
  989.  
  990.         strcpy(DownloadPath,Name);
  991.  
  992.         ConfigChanged = TRUE;
  993.  
  994.         Index = PathPart(DownloadPath);
  995.  
  996.         *Index = 0;
  997.     }
  998.  
  999.     TransferAborted = FALSE;
  1000.  
  1001.     TransferFailed = TRUE;
  1002.  
  1003.     TransferError = FALSE;
  1004.  
  1005.     if(Name)
  1006.     {
  1007.         struct Window *ThisWindow;
  1008.  
  1009.         if(ThisWindow = CreateASCIIWindow(FALSE))
  1010.         {
  1011.             struct Buffer *File;
  1012.  
  1013.             if(File = BufferOpen(Name,"w"))
  1014.             {
  1015.                 UBYTE    OtherBuffer[512];
  1016.                 LONG    Chars = 0,Lines = 0,i;
  1017.                 BYTE    Terminated = FALSE;
  1018.                 ULONG    Signals;
  1019.  
  1020.                 AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_OPENING_FILE_TXT),Name);
  1021.  
  1022.                 TransferFailed = FALSE;
  1023.  
  1024.                 Status = STATUS_DOWNLOAD;
  1025.  
  1026.                 if(DataHold)
  1027.                 {
  1028.                     LONG Size,Len;
  1029.  
  1030.                     do
  1031.                     {
  1032.                         if(DataSize > 256)
  1033.                             Size = 256;
  1034.                         else
  1035.                             Size = DataSize;
  1036.  
  1037.                         if(Len = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,DataHold,Size,OtherBuffer))
  1038.                         {
  1039.                             if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1040.                             {
  1041.                                 for(i = 0 ; i < Len ; i++)
  1042.                                 {
  1043.                                     if(OtherBuffer[i] == '\r')
  1044.                                         Lines++;
  1045.  
  1046.                                     if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1047.                                     {
  1048.                                         Len = i;
  1049.  
  1050.                                         Terminated = TRUE;
  1051.  
  1052.                                         break;
  1053.                                     }
  1054.                                 }
  1055.                             }
  1056.                             else
  1057.                             {
  1058.                                 for(i = 0 ; i < Len ; i++)
  1059.                                 {
  1060.                                     if(OtherBuffer[i] == '\r')
  1061.                                         Lines++;
  1062.                                 }
  1063.                             }
  1064.  
  1065.                             if(Len)
  1066.                             {
  1067.                                 Chars += Len;
  1068.  
  1069.                                 if(BufferWrite(File,OtherBuffer,Len) != Len)
  1070.                                 {
  1071.                                     TransferFailed = Terminated = TRUE;
  1072.  
  1073.                                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1074.                                 }
  1075.                             }
  1076.                         }
  1077.  
  1078.                         if(!Config -> TransferConfig -> QuietTransfer)
  1079.                         {
  1080.                             ConProcess(DataHold,Size);
  1081.  
  1082.                             Status = STATUS_DOWNLOAD;
  1083.                         }
  1084.  
  1085.                         DataSize -= Size;
  1086.  
  1087.                         if(DataSize > 0)
  1088.                             DataHold += Size;
  1089.                         else
  1090.                             DataHold = NULL;
  1091.                     }
  1092.                     while(DataHold && !Terminated);
  1093.  
  1094.                     RestartSerial(FALSE);
  1095.  
  1096.                     UpdateASCIIWindow(ThisWindow,Chars,0,Lines);
  1097.                 }
  1098.  
  1099.                 if(!Terminated)
  1100.                 {
  1101.                     StartTime(5,0);
  1102.  
  1103.                     do
  1104.                     {
  1105.                         Signals = Wait(SIG_BREAK | SIG_SERIAL | SIG_TIMER | PORTMASK(ThisWindow -> UserPort));
  1106.  
  1107.                         if(Signals & PORTMASK(ThisWindow -> UserPort))
  1108.                         {
  1109.                             if(HandleASCIIWindow(ThisWindow))
  1110.                                 break;
  1111.                         }
  1112.  
  1113.                         if(Signals & SIG_SERIAL)
  1114.                         {
  1115.                             StopTime();
  1116.  
  1117.                             if(!WaitSerialRead())
  1118.                             {
  1119.                                 LONG Length;
  1120.  
  1121.                                 BytesIn++;
  1122.  
  1123.                                 if(!Config -> TransferConfig -> QuietTransfer)
  1124.                                 {
  1125.                                     ConProcess(ReadBuffer,1);
  1126.  
  1127.                                     Status = STATUS_DOWNLOAD;
  1128.                                 }
  1129.  
  1130.                                 if(Length = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,ReadBuffer,1,OtherBuffer))
  1131.                                 {
  1132.                                     if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1133.                                     {
  1134.                                         for(i = 0 ; i < Length ; i++)
  1135.                                         {
  1136.                                             if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1137.                                             {
  1138.                                                 Length = i;
  1139.  
  1140.                                                 Terminated = TRUE;
  1141.  
  1142.                                                 break;
  1143.                                             }
  1144.                                         }
  1145.  
  1146.                                         if(Terminated)
  1147.                                         {
  1148.                                             RestartSerial(FALSE);
  1149.  
  1150.                                             break;
  1151.                                         }
  1152.                                     }
  1153.  
  1154.                                     if(Length)
  1155.                                     {
  1156.                                         if(BufferWrite(File,OtherBuffer,Length) != Length)
  1157.                                         {
  1158.                                             TransferFailed = Terminated = TRUE;
  1159.  
  1160.                                             AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1161.                                         }
  1162.  
  1163.                                         for(i = 0 ; i < Length ; i++)
  1164.                                         {
  1165.                                             if(OtherBuffer[i] == '\r')
  1166.                                                 Lines++;
  1167.                                         }
  1168.  
  1169.                                         Chars += Length;
  1170.                                     }
  1171.                                 }
  1172.  
  1173.                                     /* Check how many bytes are still in
  1174.                                      * the serial buffer.
  1175.                                      */
  1176.  
  1177.                                 if(Length = GetSerialWaiting())
  1178.                                 {
  1179.                                     if(Length > SerialBufferSize)
  1180.                                         Length = SerialBufferSize;
  1181.  
  1182.                                     if(Length > Config -> SerialConfig -> Quantum)
  1183.                                         Length = Config -> SerialConfig -> Quantum;
  1184.  
  1185.                                     if(Length > 256)
  1186.                                         Length = 256;
  1187.  
  1188.                                     if(!DoSerialRead(ReadBuffer,Length))
  1189.                                     {
  1190.                                         BytesIn += Length;
  1191.  
  1192.                                             /* Send the data to the console. */
  1193.  
  1194.                                         if(!Config -> TransferConfig -> QuietTransfer)
  1195.                                         {
  1196.                                             ConProcess(ReadBuffer,Length);
  1197.  
  1198.                                             Status = STATUS_DOWNLOAD;
  1199.                                         }
  1200.  
  1201.                                         if(Length = MangleASCIIBuffer(Config -> TransferConfig -> ReceiveCR,Config -> TransferConfig -> ReceiveLF,ReadBuffer,Length,OtherBuffer))
  1202.                                         {
  1203.                                             if(Config -> TransferConfig -> IgnoreDataPastArnold)
  1204.                                             {
  1205.                                                 for(i = 0 ; i < Length ; i++)
  1206.                                                 {
  1207.                                                     if(OtherBuffer[i] == '\r')
  1208.                                                         Lines++;
  1209.  
  1210.                                                     if(OtherBuffer[i] == Config -> TransferConfig -> TerminatorChar)
  1211.                                                     {
  1212.                                                         Length = i;
  1213.  
  1214.                                                         Terminated = TRUE;
  1215.  
  1216.                                                         break;
  1217.                                                     }
  1218.                                                 }
  1219.                                             }
  1220.                                             else
  1221.                                             {
  1222.                                                 for(i = 0 ; i < Length ; i++)
  1223.                                                 {
  1224.                                                     if(OtherBuffer[i] == '\r')
  1225.                                                         Lines++;
  1226.                                                 }
  1227.                                             }
  1228.  
  1229.                                             if(Length)
  1230.                                             {
  1231.                                                 Chars += Length;
  1232.  
  1233.                                                 if(BufferWrite(File,OtherBuffer,Length) != Length)
  1234.                                                 {
  1235.                                                     TransferFailed = Terminated = TRUE;
  1236.  
  1237.                                                     AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_WRITING_FILE_TXT),Name);
  1238.                                                 }
  1239.                                             }
  1240.                                         }
  1241.                                     }
  1242.                                 }
  1243.  
  1244.                                 UpdateASCIIWindow(ThisWindow,Chars,0,Lines);
  1245.                             }
  1246.  
  1247.                             StartTime(5,0);
  1248.  
  1249.                             Signals &= ~SIG_TIMER;
  1250.  
  1251.                             RestartSerial(FALSE);
  1252.                         }
  1253.  
  1254.                         if(Signals & SIG_TIMER)
  1255.                             Terminated = TRUE;
  1256.  
  1257.                         if(Signals & SIG_BREAK)
  1258.                             TransferAborted = Terminated = TRUE;
  1259.                     }
  1260.                     while(!Terminated);
  1261.  
  1262.                     StopTime();
  1263.                 }
  1264.  
  1265.                 BufferClose(File);
  1266.             }
  1267.             else
  1268.             {
  1269.                 AddASCIIMessage(ThisWindow,LocaleString(MSG_ASCIIPANEL_ERROR_OPENING_FILE_TXT),Name);
  1270.  
  1271.                 TransferFailed = TRUE;
  1272.             }
  1273.  
  1274.             if(TransferFailed || TransferError)
  1275.                 WakeUp(ThisWindow,SOUND_BADTRANSFER);
  1276.             else
  1277.             {
  1278.                 WakeUp(ThisWindow,SOUND_GOODTRANSFER);
  1279.  
  1280.                 WaitTime(2,0);
  1281.             }
  1282.  
  1283.             DeleteASCIIWindow(ThisWindow,TransferFailed && WaitForIt);
  1284.         }
  1285.     }
  1286.  
  1287.     if(TransferFailed || TransferAborted)
  1288.         Say(LocaleString(MSG_GLOBAL_TRANSFER_FAILED_OR_ABORTED_TXT));
  1289.     else
  1290.         Say(LocaleString(MSG_GLOBAL_TRANSFER_COMPLETED_TXT));
  1291.  
  1292.     if(OldDir)
  1293.         CurrentDir(OldDir);
  1294.  
  1295.     if(NewDir)
  1296.         UnLock(NewDir);
  1297.  
  1298.     SendAbort = FALSE;
  1299.  
  1300.     Status = OldStatus;
  1301.  
  1302.     ReleaseWindows();
  1303.  
  1304.     DownloadPath = NULL;
  1305.  
  1306.     DidTransfer = FALSE;
  1307.  
  1308.     if(WaitForIt)
  1309.     {
  1310.         if(Config -> CommandConfig -> DownloadMacro[0])
  1311.             SerialCommand(Config -> CommandConfig -> DownloadMacro);
  1312.     }
  1313.  
  1314.     DidTransfer = FALSE;
  1315.  
  1316.     return(DidSend);
  1317. }
  1318.